//package com.kitbox.hl.meshow.common.utils;
//
//
//import jxl.format.*;
//import jxl.write.*;
//import org.apache.commons.beanutils.BeanComparator;
//import org.apache.commons.beanutils.BeanUtils;
//import org.apache.commons.beanutils.NestedNullException;
//import org.apache.commons.beanutils.PropertyUtils;
//import org.apache.commons.collections.ComparatorUtils;
//import org.apache.commons.collections.comparators.ComparableComparator;
//import org.apache.commons.collections.comparators.ComparatorChain;
//import org.apache.commons.lang.StringUtils;
//import org.apache.log4j.Logger;
//import org.springframework.util.CollectionUtils;
//
//import javax.servlet.http.HttpServletRequest;
//import java.io.*;
//import java.lang.reflect.InvocationTargetException;
//import java.lang.reflect.Method;
//import java.security.MessageDigest;
//import java.text.DecimalFormat;
//import java.text.MessageFormat;
//import java.text.SimpleDateFormat;
//import java.util.*;
//import java.util.regex.Matcher;
//import java.util.regex.Pattern;
//
///**
// * 系统公用方法
// */
//@SuppressWarnings(value = "all")
//public class CommonUtil {
//
//	public static final String defaultFormat="yyyy-MM-dd";
//
//	/** log4j instance. */
//	private static Logger log = Logger.getLogger(CommonUtil.class);
//
//	/**
//	 * 判断Collection是否不为空
//	 *
//	 * @param collection
//	 *            需要判断的Collection
//	 * @return boolean
//	 */
//	public static boolean collectionIsNotEmpty(Collection collection) {
//		return !collectionIsEmpty(collection);
//	}
//
//	/**
//	 * 判断Collection是否为空
//	 *
//	 * @param collection
//	 *            需要判断的Collection
//	 * @return boolean
//	 */
//	public static boolean collectionIsEmpty(Collection collection) {
//		if (collection == null || collection.size() == 0) {
//			return true;
//		}
//		return false;
//	}
//
//	/**
//	 * 判断Map是否不为空
//	 *
//	 * @param map
//	 *            需要判断的Collection
//	 * @return boolean
//	 */
//	public static boolean collectionIsNotEmpty(Map map) {
//		return !collectionIsEmpty(map);
//	}
//
//	/**
//	 * 判断Map是否为空
//	 *
//	 * @param map
//	 *            需要判断的Collection
//	 * @return boolean
//	 */
//	public static boolean collectionIsEmpty(Map map) {
//		if (map == null || map.size() == 0) {
//			return true;
//		}
//		return false;
//	}
//
//	/**
//	 * 判断对象数组是否为空
//	 *
//	 * @param objs
//	 *            需要判断的对象数组
//	 * @return boolean
//	 */
//	public static boolean arrayIsNotEmpty(Object[] objs) {
//		if (objs == null || objs.length == 0) {
//			return false;
//		}
//		return true;
//	}
//
//	/**
//	 * 判断对象数组是否为空
//	 *
//	 * @param objs
//	 *            需要判断的对象数组
//	 * @return boolean
//	 */
//	public static boolean arrayIsEmpty(Object[] objs) {
//		if (objs == null || objs.length == 0) {
//			return true;
//		}
//		return false;
//	}
//
//	/**
//	 * 判断字符串是否为null 或者 trim后为"";
//	 *
//	 * @param str
//	 * @return
//	 */
//	public static boolean isTrimEmpty(String str) {
//		if (str == null || "".equals(str.trim())) {
//			return true;
//		}
//		return false;
//	}
//
//	/**
//	 * 判断字符串是否 不 为null 而且 trim后 不 等于"";
//	 *
//	 * @param str
//	 * @return
//	 */
//	public static boolean isNotTrimEmpty(String str) {
//		return !isTrimEmpty(str);
//	}
//
//	/**
//	 * 读取一个属性文件
//	 *
//	 * @param propName
//	 *            属性文件名称
//	 * @return 返回属性文件
//	 */
//	public static Properties getProperties(String propName) throws Exception {
//		Properties p = null;
//		try {
//			InputStream in = ClassLoader.getSystemResourceAsStream(propName);
//			if (in == null) {
//				in = CommonUtil.class.getResourceAsStream(propName);
//			}
//			if (in == null) {
//				in = CommonUtil.class.getClassLoader().getResourceAsStream(
//						propName);
//			}
//			p = getProperties(in);
//		} catch (Exception ex) {
//			log.error("文件不存在：", ex);
//			throw new Exception("");
//		}
//		return p;
//	}
//
//	/**
//	 * 读取一个属性文件
//	 *
//	 * @param propName
//	 *            属性文件名称
//	 * @return 返回属性文件
//	 */
//	public static Properties getPropertiesByContext(String propName)
//			throws Exception {
//		log.debug("加载属性文件：" + propName);
//		ClassLoader classLoader = Thread.currentThread()
//				.getContextClassLoader();
//		InputStream in = classLoader.getResourceAsStream(propName);
//		return getProperties(in);
//	}
//
//	/**
//	 * 读取一个属性文件
//	 *
//	 * @param in
//	 *            文件流
//	 * @return 返回属性文件
//	 */
//	private static Properties getProperties(InputStream in) throws Exception {
//		Properties p = new Properties();
//		if (in != null) {
//			p.load(in);
//			in.close();
//		}
//		log.debug("属性文件：" + p);
//		return p;
//	}
//
//	/**
//	 * 替换路径当中的空格转义符号
//	 *
//	 * @param p
//	 *            文件的物理路径名称
//	 * @return 物理路径名称
//	 */
//	public static String replacePathSpace(String p) throws Exception {
//		if (p != null && p.contains("%20")) {
//			p = p.replaceAll("%20", " ");
//		}
//		return p;
//	}
//
//	/**
//	 * 获取一个带首字母拼音的字符串，可用来索引，比如参数为 国家 ，返回 G国家
//	 *
//	 * @param str
//	 * @return
//	 */
//	public static String getChoosableLabel(String str) {
//		// return CnToSpell.getFirstWordSpell(str == null ? "" :
//		// str).toUpperCase() + " " + (str == null ? "" : str);
//		return PinyinConv.cnAppend1stPy(str == null ? "" : str);
//	}
//
//
//
//	/**
//	 * 把范型为ListValueBean的list转化为相应的Map
//	 */
//	public static Map<Long, String> longStringColumnList2Map(List<Object[]> list) {
//		Map<Long, String> result = new HashMap<Long, String>();
//		for (Object[] objArr : list) {
//			result.put(getLongValue(objArr[0]), getStringValue(objArr[1]));
//		}
//		return result;
//	}
//
//
//	/**
//	 * 过滤list,获取一个全新的List对象，目的是为了保护srcList不被破坏
//	 *
//	 * @param temp
//	 * @param filters
//	 * @return 测试过apach的beanUtils拿出来空的话为""，不为null 以后应该自己封装getProperty方法
//	 * @throws Exception
//	 */
//	public static List getConditionFiltedList(List temp,
//			List<ListFilter> filters) throws Exception {
//		List result = new ArrayList();
//		for (Object obj : temp) {
//			boolean flag = true;
//			// 条件过滤
//			if (!CollectionUtils.isEmpty(filters)) {
//				for (ListFilter filter : filters) {
//					if (filter.getIfEquals()) {
//						if (!filter.getValue().equals(
//								BeanUtils.getProperty(obj, filter.getKey()
//										.toString()))) {
//							flag = false;
//							break;
//						}
//					} else {
//						if (StringUtils.isEmpty(filter.getValue())
//								&& StringUtils.isEmpty(BeanUtils.getProperty(
//										obj, filter.getKey().toString()))) {
//							flag = false;
//							break;
//						}
//						if (filter.getValue().equals(
//								String.valueOf(BeanUtils.getProperty(obj,
//										filter.getKey().toString())))) {
//							flag = false;
//							break;
//						}
//					}
//				}
//			}
//			if (flag) {
//				result.add(obj);
//			}
//		}
//		return result;
//	}
//
//	/**
//	 * 增加一个ListFilter范型的属性过滤器
//	 */
//	public static ListFilter createfilter(String column, Serializable value,
//			boolean ifEquals) {
//		ListFilter filter = new ListFilter();
//		filter.setKey(column);
//		filter.setValue(String.valueOf(value));
//		filter.setIfEquals(ifEquals);
//		return filter;
//	}
//
//	/**
//	 * 上传专用的方法
//	 *
//	 * @param srcFile
//	 * @param relativePath
//	 * @param fileName
//	 */
//	public static String uploadFile(File srcFile, String relativePath,
//			String fileName) throws Exception {
//		String flag = DateTimeUtil.getFormatDate(DateTimeUtil.getCurrentTime(),
//				BaseConstants.DATE_PATTERN_2);
//		// String baseDir =
//		// getProperties(BaseConstants.SYSTEM_PROP_FILE).getProperty(BaseConstants.SYSTEM_FILE_DIR);
//		String baseDir = "";
//		String dir = baseDir + BaseConstants.SYSTEM_SEPARATOR + relativePath
//				+ BaseConstants.SYSTEM_SEPARATOR + flag;
//		log.debug("====XXXXXXX===文件保存的物理路径是：" + dir);
//		File file = new File(dir);
//		if (!file.exists()) {
//			file.mkdirs();
//		}
//		String targetPath = dir + BaseConstants.SYSTEM_SEPARATOR + fileName;
//		File targetFile = new File(targetPath);
//		copyFile(srcFile, targetFile);
//
//		String contextPath = BaseConstants.SYSTEM_SEPARATOR + relativePath
//				+ BaseConstants.SYSTEM_SEPARATOR + flag
//				+ BaseConstants.SYSTEM_SEPARATOR + fileName;
//		return contextPath;
//	}
//
//	/**
//	 * 文件复制
//	 *
//	 * @param srcFile
//	 * @param targetFile
//	 */
//	public static void copyFile(File srcFile, File targetFile) {
//		try {
//			InputStream in = null;
//			OutputStream out = null;
//			try {
//				in = new BufferedInputStream(new FileInputStream(srcFile),
//						BaseConstants.BUFFER_SIZE);
//				out = new BufferedOutputStream(
//						new FileOutputStream(targetFile),
//						BaseConstants.BUFFER_SIZE);
//				byte[] buffer = new byte[BaseConstants.BUFFER_SIZE];
//				int i = 0;
//				while ((i = in.read(buffer)) > 0) {
//					out.write(buffer, 0, i);
//				}
//			} finally {
//				if (null != in) {
//					in.close();
//				}
//				if (null != out) {
//					out.close();
//				}
//			}
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//	}
//
//	/**
//	 * 获取文件的后缀名
//	 *
//	 * @param fileName
//	 * @return
//	 */
//	public static String getExtentsName(String fileName) {
//		if (fileName.contains(".")) {
//			int pos = fileName.lastIndexOf(".");
//			return fileName.substring(pos);
//		}
//		return "";
//	}
//
//	/**
//	 * 当文件名中包括 $^+(){}[] 这些符号时，都会出现问题。 此方法有待改进
//	 *
//	 * @param nameString
//	 * @param replaceStr
//	 * @return
//	 */
//	public static String replaceFileNameSpecial(String nameString,
//			String replaceStr) {
//		if (StringUtils.isEmpty(nameString)) {
//			return "";
//		}
//		return nameString.replace("$", replaceStr).replace("^", replaceStr)
//				.replace("+", replaceStr).replace("(", replaceStr)
//				.replace(")", replaceStr).replace("{", replaceStr)
//				.replace("}", replaceStr).replace("[", replaceStr)
//				.replace("]", replaceStr);
//	}
//
//	/**
//	 * 将对象转换成字符串,如果对象为Null,则返回空字符串
//	 *
//	 * @param objs
//	 *            需要判断的对象数组
//	 * @return boolean
//	 */
//	public static String convertObjToStr(Object obj) {
//		if (obj != null) {
//			return obj.toString();
//		}
//		return "";
//	}
//
//	/**
//	 * 判断字符串是否为数字
//	 *
//	 * @param num
//	 * @return
//	 */
//	public static boolean isNumber(String num) {
//		if (StringUtils.isBlank(num)) {
//			return false;
//		}
//		try {
//			Double.parseDouble(num);
//			return true;
//		} catch (NumberFormatException e) {
//			return false;
//		}
//	}
//
//	/**
//	 * 排序工具，list为集合，properties是变参，根据传入的参数排序
//	 *
//	 * @param list
//	 * @param properties
//	 */
//	@SuppressWarnings("unchecked")
//	public static void comparatorList(List list, String... properties) {
//		List<BeanComparator> sortFields = new ArrayList<BeanComparator>();
//		for (String property : properties) {
//			sortFields.add(new BeanComparator(property));
//		}
//		ComparatorChain multiSort = new ComparatorChain(sortFields);
//		Collections.sort(list, multiSort);
//	}
//
//	/**
//	 * 获取降序的列表
//	 *
//	 * @param list
//	 * @param properties
//	 */
//	public static void comparatorDescList(List list, String... properties) {
//		List<BeanComparator> sortFields = new ArrayList<BeanComparator>();
//		for (String property : properties) {
//			Comparator comp = ComparableComparator.getInstance();
//			comp = ComparatorUtils.reversedComparator(comp);// 将序
//			sortFields.add(new BeanComparator(property, comp));
//		}
//		ComparatorChain multiSort = new ComparatorChain(sortFields);
//		Collections.sort(list, multiSort);
//	}
//
//	/**
//	 * 获取带参数的提示信息
//	 *
//	 * @param msg
//	 * @param args
//	 * @return
//	 */
//	public static String getMsg(String msg, Object... args) {
//		if (StringUtils.isNotEmpty(msg) && args != null && args.length > 0) {
//			MessageFormat format = new MessageFormat(msg);
//			msg = format.format(args);
//		}
//		return msg;
//	}
//
//	/**
//	 * 比较2个浮点数是否相等
//	 *
//	 * @param a
//	 * @param b
//	 * @return
//	 * @throws Exception
//	 */
//	public static boolean equalsDouble(Double a, Double b) throws Exception {
//		boolean result = false;
//		if (a != null && b != null) {
//			result = Math.abs(a.doubleValue() - b.doubleValue()) < BaseConstants.PRECISION_VAL;
//		}
//		return result;
//	}
//
//	/**
//	 * 覆盖PropertyUtils.getProperty()方法，防止空指针异常
//	 *
//	 * @param o
//	 * @param prop
//	 * @return
//	 */
//	public static Object getProperty(Object o, String prop) {
//		Object result = null;
//		try {
//			result = PropertyUtils.getProperty(o, prop);
//		} catch (NestedNullException nne) {
//			log.warn("属性：" + prop + "值为空", nne);
//		} catch (Exception e) {
//			log.warn("属性：" + prop + "转换出错！", e);
//		}
//		return result;
//	}
//
//	/**
//	 * 设置属性
//	 * @param o
//	 * @param prop
//	 * @param propValue
//	 */
//	public static void setProperty(Object o, String prop, String propValue) {
//		try {
//			PropertyUtils.setProperty(o, prop, propValue);
//		} catch (NestedNullException nne) {
//			log.warn("属性：" + prop + "值为空", nne);
//		} catch (Exception e) {
//			log.warn("属性：" + prop + "转换出错！", e);
//		}
//	}
//
//
//	/**
//	 * 删除集合中的空对象
//	 *
//	 * @param c
//	 */
//	public static void removeNullObject(Collection c) {
//		if (c != null) {
//			List listnull = new ArrayList();
//			listnull.add(null);
//			c.removeAll(listnull);
//		}
//
//	}
//
//	/**
//	 * 把null 转换成0L
//	 *
//	 * @param resource
//	 * @return
//	 */
//	public static Long nullToZero(Long resource) {
//		return resource == null ? 0L : resource;
//	}
//
//	/**
//	 * 把null 转换成0.0
//	 *
//	 * @param resource
//	 * @return
//	 */
//	public static Double nullToZero(Double resource) {
//		return resource == null ? 0.0 : resource;
//	}
//
//	/**
//	 * 转换字符串，如何是日期类型的字段，则转换成标准日期格式
//	 *
//	 * @param 需要转换的对象
//	 * @return 转换字符串
//	 */
//	public static String formatNumber(Object o, String pattern) {
//		try {
//			String p = BaseConstants.NUMBER_PATTERN;
//			if (StringUtils.isNotEmpty(pattern)) {
//				p = pattern;
//			}
//			DecimalFormat df = new DecimalFormat(p);
//			if (o != null) {
//				return df.format(o);
//			} else {
//				return "";
//			}
//		} catch (Exception e) {
//			log.error("格式化数字错误：" + pattern, e);
//			return convertObjToStr(o);
//		}
//	}
//
//	/**
//	 * 判断一个List中的对象数据是否有与传入的样本有不一样的
//	 *
//	 * @param listValue
//	 *            需要判断的List ,sample 样本
//	 * @return true:相同,false:不同
//	 */
//	public static boolean sameValueInList(List listValue, Object sample)
//			throws Exception {
//		boolean mark = true;
//		for (Object oo : listValue) {
//			if (!oo.equals(sample)) {
//				mark = false;
//				break;
//			}
//		}
//		return mark;
//	}
//
//	/**
//	 * 如果List中不存在这个元素，则增加，反之不增加
//	 *
//	 * @param list
//	 * @param obj
//	 * @return 增加了返回true，否则返回false
//	 */
//	public static boolean addUniqueObjList(List list, Object obj) {
//		if (list.contains(obj) || obj == null) {
//			return false;
//		} else {
//			list.add(obj);
//			return true;
//		}
//	}
//
//	/**
//	 * 获取in 条件
//	 *
//	 * @param ids
//	 * @return
//	 */
//	public static String getInConditionWithIds(List<Long> ids, String name) {
//		StringBuffer inCondition = new StringBuffer("(" + name + " in (");
//		int flag = 0;
//		for (Object id : ids) {
//			if (flag == 999) {
//				inCondition = new StringBuffer(inCondition.substring(0,
//						inCondition.length() - 1));
//				inCondition.append(") or " + name + " in (");
//				flag = 0;
//			}
//			inCondition.append(id + ",");
//			flag++;
//		}
//		String str = inCondition.toString();
//		if (str.endsWith(",")) {
//			str += "-98765";
//		} else {
//			str += "-98765, -98763";
//		}
//		str += ") ) ";
//		return str;
//	}
//
//	/**
//	 * 获取in 条件
//	 *
//	 * @param ids
//	 * @return
//	 */
//	public static String getInConditionWithIds(Long[] ids, String name) {
//		return getInConditionWithIds(arrayToList(ids), name);
//	}
//
//	/**
//	 * 数组转换List
//	 *
//	 * @param ids
//	 * @return
//	 */
//	public static List<Long> arrayToList(String[] ids) {
//		List<Long> list = new ArrayList<Long>();
//		if (ids != null) {
//			for (int i = 0; i < ids.length; i++) {
//				if (!"".equals(ids[i].trim()))
//					list.add(Long.valueOf(ids[i]));
//			}
//		}
//		return list;
//	}
//
//	/**
//	 * 数组转换List
//	 *
//	 * @param ids
//	 * @return
//	 */
//	public static List<Long> arrayToList(Long[] ids) {
//		List<Long> list = new ArrayList<Long>();
//		if (ids != null) {
//			for (int i = 0; i < ids.length; i++) {
//				list.add(ids[i]);
//			}
//		}
//		return list;
//	}
//
//	/**
//	 * List转换数组
//	 *
//	 * @param ids
//	 * @return
//	 */
//	public static Long[] listToLongArray(List<Long> idList) {
//		Long[] ids = null;
//		if (collectionIsNotEmpty(idList)) {
//			ids = new Long[idList.size()];
//			for (int i = 0; i < ids.length; i++) {
//				ids[i] = idList.get(i);
//			}
//		}
//		return ids;
//	}
//
//	public static String MD5(String s) {
//		char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
//				'a', 'b', 'c', 'd', 'e', 'f' };
//		try {
//			byte[] strTemp = s.getBytes();
//			MessageDigest mdTemp = MessageDigest.getInstance("MD5");
//			mdTemp.update(strTemp);
//			byte[] md = mdTemp.digest();
//			int j = md.length;
//			char str[] = new char[j * 2];
//			int k = 0;
//			for (int i = 0; i < j; i++) {
//				byte byte0 = md[i];
//				str[k++] = hexDigits[byte0 >>> 4 & 0xf];
//				str[k++] = hexDigits[byte0 & 0xf];
//			}
//			return new String(str);
//		} catch (Exception e) {
//			return null;
//		}
//	}
//
//
//
//	/**
//	 * 合并数据公共方法，陷阱，Apache的PropertyUtils.getProperty获取的是真正的数据类型，
//	 * BeanUtils获取的不是null就是String
//	 *
//	 * @param list
//	 *            数据集合
//	 * @param combineCondition
//	 *            合并条件，当n个对象里面 这个数组里面的所有属性都相等，就会被合并
//	 * @param combineColumn
//	 *            合并n条数据的时候，这个里面的字段将做加和处理，支持Long，Double，String加和,这些属性必须在obj中有一个域
//	 *            ，并有setter和getter
//	 * @throws Exception
//	 */
//	public static void combineDatas(List srcList, String[] combineCondition,
//			String[] combineColumn) throws Exception {
//		comparatorList(srcList, combineCondition);
//		List removeList = new ArrayList();
//		Object topObj = null;
//		for (Object obj : srcList) {
//			if (topObj == null
//					|| !ifPropertiesEquals(topObj, obj, combineCondition)) {
//				topObj = obj;
//			} else {
//				for (String property : combineColumn) {
//					Object topObjValue = PropertyUtils.getProperty(topObj,
//							property);
//					Object currentObjValue = PropertyUtils.getProperty(obj,
//							property);
//					if (currentObjValue != null) {
//						if (topObjValue == null) {
//							PropertyUtils.setProperty(topObj, property,
//									currentObjValue);
//						} else {
//							if (topObjValue instanceof Double) {
//								Double value = Double.valueOf(topObjValue
//										.toString())
//										+ Double.valueOf(currentObjValue
//												.toString());
//								PropertyUtils.setProperty(topObj, property,
//										value);
//							} else if (topObjValue instanceof Long) {
//								Long value = Long.valueOf(topObjValue
//										.toString())
//										+ Long.valueOf(currentObjValue
//												.toString());
//								PropertyUtils.setProperty(topObj, property,
//										value);
//							} else if (topObjValue instanceof String) {
//								String value = topObjValue.toString() + ", "
//										+ currentObjValue.toString();
//								PropertyUtils.setProperty(topObj, property,
//										value);
//							}
//						}
//					}
//				}
//				removeList.add(obj);
//			}
//		}
//		srcList.removeAll(removeList);
//	}
//
//	/**
//	 * 判断2个对象中的 一组 属性是否完全相等
//	 *
//	 * @param topObj
//	 * @param obj
//	 * @param combineCondition
//	 * @return throws Exception
//	 */
//	public static boolean ifPropertiesEquals(Object fstObj, Object scdObj,
//			String... properties) throws Exception {
//		if (fstObj == null || scdObj == null) {
//			return false;
//		}
//		for (String property : properties) {
//			Object fst = BeanUtils.getProperty(fstObj, property);
//			Object scd = BeanUtils.getProperty(scdObj, property);
//			if (fst == null) {
//				if (scd != null) {
//					return false;
//				}
//			} else {
//				if (!fst.equals(scd)) {
//					return false;
//				}
//			}
//		}
//		return true;
//	}
//
//	/**
//	 * 获取框架公共的Excel导出时表头格式
//	 *
//	 * @return
//	 * @throws WriteException
//	 */
//	public static WritableCellFormat getExcelDefaultTitleFormat()
//			throws WriteException {
//		WritableFont wf = new WritableFont(WritableFont.TIMES);
//		wf.setBoldStyle(WritableFont.BOLD);
//		WritableCellFormat wff = new WritableCellFormat(wf);
//		wff.setBackground(Colour.GRAY_50);
//		wff.setAlignment(Alignment.CENTRE);
//		wff.setVerticalAlignment(VerticalAlignment.CENTRE);
//		// BorderLineStyle.THICK粗边框，THIN是细边框
//		wff.setBorder(Border.ALL, BorderLineStyle.THIN, Colour.BLACK);
//		return wff;
//	}
//
//	/**
//	 * 获取框架公共的Excel导出时数据表格式
//	 *
//	 * @return
//	 * @throws WriteException
//	 */
//	public static WritableCellFormat getExcelDefaultCellFormat()
//			throws WriteException {
//		WritableFont wf = new WritableFont(WritableFont.TIMES);
//		WritableCellFormat wff = new WritableCellFormat(wf);
//		wff.setBackground(Colour.GRAY_25);
//		wff.setBorder(Border.ALL, BorderLineStyle.THIN, Colour.BLACK);
//		return wff;
//	}
//
//	/**
//	 * 公共导出excel方法，第一个集合是数据集合，第二个Map是行数据对应的样式，第三个是WritableSheet对象
//	 * index为从第几行开始输出数据，根据表头占用行数判断
//	 *
//	 * @param dataList
//	 * @param styles
//	 * @param wSheet
//	 * @param index
//	 * @throws Exception
//	 */
//	public static void exportExcel(List<List<Object>> dataList,
//			Map<List<Object>, WritableCellFormat> styles, WritableSheet wSheet,
//			int index) throws Exception {
//		for (int i = 0, size = dataList.size(); i < size; i++) {
//			List<Object> data = dataList.get(i);
//			WritableCellFormat cellFormat = styles.get(data);
//			if (cellFormat == null) {
//				cellFormat = getExcelDefaultCellFormat();
//			}
//			for (int j = 0, jSize = data.size(); j < jSize; j++) {
//				Object obj = data.get(j);
//				WritableCell wCell = new Label(j, i + index, "-", cellFormat);
//				if (obj != null) {
//					if (obj instanceof Double || obj instanceof Long) {
//						wCell = new Number(j, i + index, Double.valueOf(obj
//								.toString()), cellFormat);
//					} else {
//						wCell = new Label(j, i + index, obj.toString(),
//								cellFormat);
//					}
//				}
//				wSheet.addCell(wCell);
//			}
//		}
//	}
//
//	/**
//	 * 更改entity字段，不执行update
//	 *
//	 * @param entity
//	 * @param column
//	 * @param value
//	 * @throws Exception
//	 */
//	public static void doAjaxUpdate(Object entity, String column, String value)
//			throws Exception {
//		Class classType = entity
//				.getClass()
//				.getMethod(
//						"get" + column.substring(0, 1).toUpperCase()
//								+ column.substring(1)).getReturnType();
//		// 根据字段不同
//		if (StringUtils.isEmpty(value)) {
//			Method method = entity.getClass().getMethod(
//					"set" + column.substring(0, 1).toUpperCase()
//							+ column.substring(1), classType);
//			if (classType.toString().toLowerCase().contains("date")) {
//				Date date = null;
//				method.invoke(entity, date);
//			} else if (classType.toString().toLowerCase().contains("long")) {
//				Long l = null;
//				method.invoke(entity, l);
//			} else if (classType.toString().toLowerCase().contains("double")) {
//				Double d = null;
//				method.invoke(entity, d);
//			} else {
//				String str = null;
//				method.invoke(entity, str);
//			}
//		} else {
//			if (classType.toString().toLowerCase().contains("date")) {
//				Date date;
//				if (value.length() <= 10) {
//					date = java.sql.Date.valueOf(value);
//				} else {
//					date = java.sql.Timestamp.valueOf(value);
//				}
//				BeanUtils.copyProperty(entity, column, date);
//			} else if (classType.toString().toLowerCase().contains("long")) {
//				BeanUtils.copyProperty(entity, column, Long.valueOf(value));
//			} else if (classType.toString().toLowerCase().contains("double")) {
//				BeanUtils.copyProperty(entity, column, Double.valueOf(value));
//			} else {
//				BeanUtils.copyProperty(entity, column, value);
//			}
//		}
//	}
//
//	/**
//	 * 数据库中读取的Object类型，如果不为null,转换成Double型并返回
//	 *
//	 * @param object
//	 * @return
//	 */
//	public static Double getDoubleValue(Object object) {
//		if (object == null || "".equals(object)) {
//			return 0.0;
//		} else {
//			if (StringUtils.isEmpty(object.toString())) {
//				return 0.0;
//			}
//			return Double.valueOf(object.toString());
//		}
//	}
//
//	/**
//	 * 数据库中读取的Object类型，如果不为null,转换成Double型并返回
//	 *
//	 * @param object
//	 * @return
//	 * @throws Exception
//	 */
//	public static Date getDateValue(Object object) throws Exception {
//		if (object == null || "".equals(object)) {
//			return null;
//		} else {
//			String dateStr = object.toString();
//			if (StringUtils.isEmpty(dateStr)) {
//				return null;
//			}
//			if (dateStr.contains("/")) {
//				return new SimpleDateFormat("dd/MM/yyyy").parse(dateStr);
//			} else if (dateStr.length() <= 10) {
//				try {
//					return java.sql.Date.valueOf(dateStr);
//				} catch (Exception e) {
//					throw new Exception("时间格式错误" + dateStr);
//				}
//			} else if (dateStr.length() <= 16) {
//				try {
//					return new SimpleDateFormat("yyyy-MM-dd HH:mm")
//							.parse(dateStr);
//				} catch (Exception e) {
//					throw new Exception("时间格式错误" + dateStr);
//				}
//			} else {
//				try {
//					return java.sql.Timestamp.valueOf(dateStr);
//				} catch (Exception e) {
//					throw new Exception("时间格式错误" + dateStr);
//				}
//			}
//		}
//	}
//
//	/**
//	 * 数据库中读取的Object类型，如果不为null,转换成Long型并返回
//	 *
//	 * @param object
//	 * @return
//	 */
//	public static Long getLongValue(Object object) {
//		if (object == null || "".equals(object)) {
//			return 0l;
//		} else {
//			if (StringUtils.isEmpty(object.toString())) {
//				return null;
//			}
//			String longStr = object.toString();
//			if (longStr.contains(".")) {
//				return Long.valueOf(longStr.substring(0, longStr.indexOf(".")));
//			}
//			return Long.valueOf(longStr);
//		}
//	}
//
//	/**
//	 * 数据库中读取的Object类型，如果不为null,转换成Long型并返回
//	 *
//	 * @param object
//	 * @return
//	 */
//	public static String getStringValue(Object object) {
//		if (object == null) {
//			return null;
//		} else {
//			return object.toString();
//		}
//	}
//
//	/**
//	 * 数据库中读取的Object类型，如果不为null,转换成Long型并返回
//	 *
//	 * @param object
//	 * @return
//	 */
//	public static String getStringNotNullValue(Object object) {
//		if (object == null) {
//			return "";
//		} else {
//			return object.toString();
//		}
//	}
//
//	/**
//	 * driver_id -> driverId, id -> id, cust_operator_id - > custOperatorId
//	 *
//	 * @param sqlColumnName
//	 * @return
//	 */
//	public static String getHqlColumnBySqlColumn(String sqlColumnName) {
//		if (StringUtils.isEmpty(sqlColumnName)) {
//			return sqlColumnName;
//		}
//		String[] a = sqlColumnName.split("_");
//		String result = a[0];
//		for (int i = 1, length = a.length; i < length; i++) {
//			result += a[i].substring(0, 1).toUpperCase();
//			result += a[i].substring(1);
//		}
//		return result;
//	}
//
//	public static void main(String[] args) throws Exception {
//		System.out.println(fillString("123456", '#', 5, true));
//		System.out.println(fillStringLen("123456", '#', 5, true));
//	}
//
//	/**
//	 * 获取真实ip
//	 *
//	 * @param request
//	 * @return
//	 */
//	public static String getRealIp(HttpServletRequest request) {
//		String ip = request.getHeader("x-forwarded-for");
//		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
//			ip = request.getHeader("Proxy-Client-IP");
//		}
//		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
//			ip = request.getHeader("WL-Proxy-Client-IP");
//		}
//		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
//			ip = request.getRemoteAddr();
//		}
//		return ip;
//	}
//
//	/**
//	 * 把字符串变成需要的数据类型
//	 *
//	 * @param clazz
//	 * @param className
//	 * @param castValue
//	 * @return
//	 */
//	public static Object castValueByClass(Class clazz, String column,
//			String value) throws Exception {
//		Class classType = clazz.getMethod(
//				"get" + column.substring(0, 1).toUpperCase()
//						+ column.substring(1)).getReturnType();
//		// 根据字段不同
//		if (StringUtils.isEmpty(value)) {
//			if (classType.toString().toLowerCase().contains("date")) {
//				Date date = null;
//				return date;
//			} else if (classType.toString().toLowerCase().contains("long")) {
//				Long l = null;
//				return l;
//			} else if (classType.toString().toLowerCase().contains("double")) {
//				Double d = null;
//				return d;
//			} else {
//				String str = null;
//				return str;
//			}
//		} else {
//			if (classType.toString().toLowerCase().contains("date")) {
//				Date date;
//				if (value.length() <= 10) {
//					date = java.sql.Date.valueOf(value);
//				} else {
//					date = java.sql.Timestamp.valueOf(value);
//				}
//				return date;
//			} else if (classType.toString().toLowerCase().contains("long")) {
//				return Long.valueOf(value);
//			} else if (classType.toString().toLowerCase().contains("double")) {
//				return Double.valueOf(value);
//			} else {
//				return value;
//			}
//		}
//	}
//
//	/**
//	 * 获取Excel读取的数字型字符
//	 *
//	 * @param strObj
//	 * @return
//	 */
//	public static String getExcelCharValue(String strObj) {
//		if (strObj == null) {
//			return strObj;
//		}
//		if (strObj.contains(".")) {
//			while (strObj.endsWith("0")) {
//				strObj = strObj.substring(0, strObj.length() - 1);
//			}
//			if (strObj.endsWith(".")) {
//				strObj = strObj.substring(0, strObj.length() - 1);
//			}
//		}
//		return strObj;
//	}
//
//	/**
//	 * String数组为空，判断是不是每个String都是空的
//	 *
//	 * @param rowsInfo
//	 * @return
//	 */
//	public static boolean StringArrayIsEmpty(String[] rowsInfo) {
//		for (String s : rowsInfo) {
//			if (StringUtils.isNotEmpty(s)) {
//				return false;
//			}
//		}
//		return true;
//	}
//
//	/**
//	 * 指定了list和list里面的key字段和value字段，返回一串可索引的字符串
//	 *
//	 * @param list
//	 * @param key
//	 * @param value
//	 * @return
//	 * @throws Exception
//	 */
//	public static String listToQuickListString(List list, String key,
//			String value) throws Exception {
//		StringBuffer sb = new StringBuffer();
//		if (!CollectionUtils.isEmpty(list)) {
//			for (Object obj : list) {
//				String valueStr = BeanUtils.getProperty(obj, value);
//				valueStr = (valueStr == null ? "" : ("("
//						+ CnToSpell.getFirstSpell(valueStr) + ")" + valueStr
//						.replace("<", "&lt;"))).replace("'", "\\'");
//				sb.append("<" + valueStr + "//");
//				sb.append(BeanUtils.getProperty(obj, key));
//			}
//			sb.append("<");
//		}
//		return sb.toString();
//	}
//
//	/**
//	 * @param string
//	 *            传入的字符
//	 * @param filler
//	 *            用来填充的数字
//	 * @param totalLength
//	 *            总的字符长度
//	 * @param atEnd
//	 *            数字房子头部或者结尾
//	 * @return
//	 */
//	public static String fillString(String string, char filler,
//			int totalLength, boolean atEnd) {
//		byte[] tempbyte = string.getBytes();
//		int currentLength = tempbyte.length;
//		int delta = totalLength - currentLength;
//		for (int i = 0; i < delta; i++) {
//			/**
//			 * 将数字放在头部
//			 */
//			if (atEnd) {
//				string += filler;
//			} else {
//				/**
//				 * 将数字放在结尾
//				 */
//				string = filler + string;
//			}
//		}
//		return string;
//	}
//
//	public static String fillStringLen(String string, char filler,
//			int totalLength, boolean atEnd) {
//		if (string.length() > totalLength) {
//			return string.substring(0, totalLength);
//		} else {
//			return fillString(string, filler, totalLength, atEnd);
//		}
//	}
//
//	/**
//	 * 判断对象数组是否为空
//	 *
//	 * @param objs
//	 *            需要判断的对象数组
//	 * @return boolean
//	 */
//	public static boolean isWindows() {
//		String osName = System.getProperty("os.name");
//		if (osName == null) {
//			osName = "";
//		} else {
//			osName = osName.toUpperCase();
//		}
//		if (osName.contains("WINDOWS")) {
//			return true;
//		}
//		return false;
//	}
//
//	/**
//	 * 根据自定义短信格式返回要发送的短消息内容
//	 *
//	 * @param s
//	 * @param convertMap
//	 * @return
//	 */
//	public static String getMessage(String s, Map<String, String> convertMap) {
//		String custMessage = s;
//
//		if (custMessage != null) {
//			String regEx = "\\$\\{[a-zA-Z]*\\}";
//			Pattern p = Pattern.compile(regEx);
//			Matcher m = p.matcher(custMessage);
//			String replaceValue;
//			while (m.find()) {
//				String replaceStr = m.group();
//				String key = replaceStr.substring(2, replaceStr.length() - 1);
//				replaceValue = convertMap.get(key);
//				if (replaceValue == null) {
//					replaceValue = "";
//				}
//				custMessage = custMessage.replace(replaceStr, replaceValue);
//			}
//
//		}
//		return custMessage;
//	}
//
//	/**
//	 * 转换List到Json propertyName 可变entity属性名
//	 *
//	 * @author 朱锐
//	 * @param
//	 * @return
//	 */
//	public static String convertListToJson(List<?> sourceList,
//			String... propertyName) {
//		if (sourceList == null || sourceList.size() == 0)
//			return "null";
//		if (propertyName == null || propertyName.length == 0)
//			return "null";
//		StringBuilder builderStr = new StringBuilder("[");
//		String typeName = "";
//		for (Object item : sourceList) {
//			typeName = item.getClass().getName();
//			StringBuilder builderItem = new StringBuilder("{");
//			for (String proItem : propertyName) {
//				try {
//					if (RuiUtils.isTrimEmpty(proItem))
//						continue;
//					Method method = item.getClass().getMethod(
//							"get"
//									+ proItem.replaceFirst(proItem.substring(0,
//											1), proItem.substring(0, 1)
//											.toUpperCase()));
//					String value = method.invoke(item).toString();
//					builderItem.append("'").append(proItem).append("'")
//							.append(":").append("'").append(value).append("',");
//				} catch (SecurityException e) {
//					e.printStackTrace();
//					log.error("该属性GET方法没有开放权限！", e);
//				} catch (NoSuchMethodException e) {
//					e.printStackTrace();
//					log.error("不存在GET方法：" + propertyName, e);
//				} catch (Exception e) {
//					e.printStackTrace();
//					log.error("错误！", e);
//				}
//			}
//			builderStr.append(builderItem.substring(0,
//					builderItem.lastIndexOf(",")).concat("},"));
//		}
//		String finalResult = builderStr.substring(0,
//				builderStr.lastIndexOf(",")).concat("]");
//		System.out.println(typeName + " -> listJson == " + finalResult);
//		return finalResult;
//	}
//
//
//
//
//	/**
//	 * 根据字母排序
//	 *
//	 * @author 朱锐
//	 * @return
//	 */
//	public static <T> List<T> sortByLetter(List<T> list, final String propName) {
//		if (collectionIsEmpty(list))
//			return list;
//		Collections.sort(list, new Comparator<T>() {
//			public int compare(T o1, T o2) {
//				try {
//					String o1Prop = BeanUtils.getProperty(o1, propName);
//					String o2Prop = BeanUtils.getProperty(o2, propName);
//					if (RuiUtils.isTrimEmpty(o1Prop)
//							|| RuiUtils.isTrimEmpty(o2Prop))
//						return 0;
//					return o1Prop.charAt(0) > o2Prop.charAt(0) ? 1 : -1;
//				} catch (IllegalAccessException e) {
//					e.printStackTrace();
//				} catch (InvocationTargetException e) {
//					e.printStackTrace();
//				} catch (NoSuchMethodException e) {
//					e.printStackTrace();
//				}
//				return 0;
//			}
//		});
//		return list;
//	}
//
//	/**
//	 * 根据字母排序 (Array)
//	 *
//	 * @author 朱锐
//	 * @return
//	 */
//	public static <T> List<T[]> sortByLetterArrIndex(List<T[]> list,
//			final int index) {
//		if (collectionIsEmpty(list))
//			return null;
//		if (!list.get(0).getClass().isArray())
//			return null;
//		Collections.sort(list, new Comparator<T[]>() {
//			public int compare(T[] o1, T[] o2) {
//				String o1Prop = String.valueOf(o1[index]);
//				String o2Prop = String.valueOf(o2[index]);
//				if (o1Prop == null || o2Prop == null)
//					return 0;
//				return o1Prop.charAt(0) > o2Prop.charAt(0) ? 1 : -1;
//			}
//		});
//		return list;
//	}
//
//	/**
//	 * 判断String 是否Not In val...
//	 *
//	 * @author 朱锐
//	 * @param sourceStr
//	 * @param notInValues
//	 * @return
//	 */
//	public static boolean ifStringNotIn(String sourceStr, Object... notInValues) {
//		if (sourceStr == null || notInValues == null || notInValues.length == 0) {
//			throw new IllegalArgumentException("错误的参数！");
//		}
//		for (Object valItem : notInValues) {
//			if (sourceStr.equals(valItem))
//				return false;
//		}
//		return true;
//	}
//
//	/**
//	 * 判断String 是否 In val...
//	 *
//	 * @author 朱锐
//	 * @param sourceStr
//	 * @param notInValues
//	 * @return
//	 */
//	public static boolean ifStringIn(String sourceStr, Object... inValues) {
//		if (sourceStr == null || inValues == null || inValues.length == 0) {
//			throw new IllegalArgumentException("错误的参数！");
//		}
//		for (Object valItem : inValues) {
//			if (sourceStr.equals(valItem))
//				return true;
//		}
//		return false;
//	}
//
//	/**
//	 * 获取汉字首字母(GB2312) ZR
//	 *
//	 * @charset GB2312
//	 * @from Internet
//	 * @bugs 不支持多音字处理
//	 */
//	public static class PinyinConv {
//		// 简体中文的编码范围从B0A1（45217）一直到F7FE（63486）
//		private final static int BEGIN = 45217;
//		private final static int END = 63486;
//
//		// 按照声母表示，这个表是在GB2312中的出现的第一个汉字，也就是说“啊”是代表首字母a的第一个汉字。
//		// i, u, v都不做声母, 自定规则跟随前面的字母
//		private final static char[] chartable = { '啊', '芭', '擦', '搭', '蛾', '发',
//				'噶', '哈', '哈', '击', '喀', '垃', '妈', '拿', '哦', '啪', '期', '然',
//				'撒', '塌', '塌', '塌', '挖', '昔', '压', '匝', };
//
//		// 二十六个字母区间对应二十七个端点
//		// GB2312码汉字区间十进制表示
//		private final static int[] table = new int[] { 45217, 45253, 45761,
//				46318, 46826, 47010, 47297, 47614, 47614, 48119, 49062, 49324,
//				49896, 50371, 50614, 50622, 50906, 51387, 51446, 52218, 52218,
//				52218, 52698, 52980, 53689, 54481, END };
//
//		// 对应首字母区间表
//		private final static char[] initialtable = { 'a', 'b', 'c', 'd', 'e',
//				'f', 'g', 'h', 'h', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
//				'r', 's', 't', 't', 't', 'w', 'x', 'y', 'z', };
//		// 初始化
//		static {
//			// try {
//			// for (int i = 0; i < 26; i++) {
//			// table[i] = gbValue(chartable[i]);// 得到GB2312码的首字母区间端点表，十进制。
//			// }
//			// } catch (Throwable e) {
//			// e.printStackTrace();
//			//
//			// }
//		}
//
//		// ------------------------public方法区------------------------
//		/**
//		 * 根据一个包含汉字的字符串返回一个汉字拼音首字母的字符串 最重要的一个方法，思路如下：一个个字符读入、判断、输出
//		 *
//		 * @author Internet
//		 * @param sourceStr
//		 * @return String
//		 */
//		public static String cn2py(String sourceStr) {
//			String result = "0";
//			try {
//				for (int i = 0; i < sourceStr.length(); i++) {
//					result += char2Initial(sourceStr.charAt(i));
//				}
//			} catch (RuntimeException e) {
//				e.printStackTrace();
//			}
//			return result;
//		}
//
//		/**
//		 * 获取字符串第一个拼音
//		 *
//		 * @author 朱锐 （增）
//		 * @param sourceStr
//		 * @return char
//		 */
//		public static char cnFirst2Py(String sourceStr) {
//			if (sourceStr == null)
//				throw new NullPointerException("sourceStr cannot be null ");
//			if (sourceStr.length() == 0)
//				return '0';
//			return char2Initial(sourceStr.charAt(0));
//		}
//
//		/**
//		 * 泛型方法。 根据List 中Object 属性名 ，拼成 首声母 + 原值
//		 *
//		 * @author 朱锐 (新增)
//		 * @param list
//		 * @param propName
//		 * @return
//		 * @throws IllegalAccessException
//		 * @throws InvocationTargetException
//		 * @throws NoSuchMethodException
//		 *             List<T>
//		 */
//		public static <T> List<T> cnListAppendProp1stPy(List<T> list,
//				String propName) throws IllegalAccessException,
//				InvocationTargetException, NoSuchMethodException {
//			if (list == null)
//				throw new NullPointerException(
//						"list will be converted cannot be null !");
//			for (T listItem : list) {
//				String propValue = BeanUtils.getProperty(listItem, propName);
//				propValue = cnAppend1stPy(propValue);
//				BeanUtils.setProperty(listItem, propName, propValue);
//			}
//			return list;
//		}
//
//		/**
//		 * 泛型方法。 根据List 中Object 属性名 ，拼成 首声母 + 原值
//		 *
//		 * @author 朱锐 (新增)
//		 * @param list
//		 * @param propName
//		 * @return
//		 * @throws IllegalAccessException
//		 * @throws InvocationTargetException
//		 * @throws NoSuchMethodException
//		 *             List<T>
//		 */
//		public static <T> List<T[]> cnArrAppendIndex1stPy(List<T[]> list,
//				int index) throws IllegalAccessException,
//				InvocationTargetException, NoSuchMethodException {
//			if (list == null || list.size() == 0)
//				throw new NullPointerException(
//						"list will be converted cannot be null or empty!");
//			if (!list.get(0).getClass().isArray())
//				return null;
//			List<T[]> resultList = new ArrayList<T[]>();
//			for (T[] listItem : list) {
//				listItem[index] = (T) cnAppend1stPy(String
//						.valueOf(listItem[index]));
//				resultList.add(listItem);
//			}
//			return resultList;
//		}
//
//		/**
//		 * @author 朱锐(增)
//		 * @param sourceStr
//		 * @return String
//		 */
//		public static String cnAppend1stPy(String sourceStr) {
//			if (sourceStr == null)
//				throw new NullPointerException("sourceStr cannot be null ");
//			if (sourceStr.length() == 0)
//				return "0";
//			String first = String.valueOf(char2Initial(sourceStr.charAt(0)))
//					.toUpperCase() + "\t";
//			return first + sourceStr;
//		}
//
//		// ------------------------private方法区------------------------
//		/**
//		 * 输入字符,得到他的声母,英文字母返回对应的大写字母,其他非简体汉字返回 '0'
//		 */
//		private static char char2Initial(char ch) {
//			// 对英文字母的处理：小写字母转换为大写，大写的直接返回
//			if (ch >= 'a' && ch <= 'z')
//				return (char) (ch - 'a' + 'A');
//			if (ch >= 'A' && ch <= 'Z')
//				return ch;
//			if (ch == '鄞')
//				return 'Y';
//			// 对非英文字母的处理：转化为首字母，然后判断是否在码表范围内，
//			// 若不是，则直接返回。
//			// 若是，则在码表内的进行判断。
//			int gb = gbValue(ch);// 汉字转换首字母
//
//			if ((gb < BEGIN) || (gb > END))// 在码表区间之前，直接返回
//				return ch;
//
//			int i = 0;
//			for (; i < 26; i++) {// 判断匹配码表区间，匹配到就break,判断区间形如“[,)”
//				if (gb >= table[i] && gb < table[i + 1])
//					break;
//			}
//			if (gb == END) {// 补上GB2312区间最右端
//				i = 25;
//			}
//			return initialtable[i]; // 在码表区间中，返回首字母
//		}
//
//		/**
//		 * 取出汉字的编码 cn 汉字
//		 */
//		private static int gbValue(char ch) {// 将一个汉字（GB2312）转换为十进制表示。
//			String str = new String();
//			str += ch;
//			try {
//				byte[] bytes = str.getBytes("GB2312");
//				if (bytes.length < 2)
//					return 0;
//				return (bytes[0] << 8 & 0xff00) + (bytes[1] & 0xff);
//			} catch (RuntimeException e) {
//				e.printStackTrace();
//			} catch (UnsupportedEncodingException e) {
//			}
//			return 0;
//		}
//
//		public static void main(String[] args) throws Exception {
//			/*
//			 * System.out.println(cn2py("重庆重视发展IT行业，大多数外企，如，IBM等进驻山城"));
//			 * System.out.println(cnFirst2Py("重庆重视发展IT行业，大多数外企，如，IBM等进驻山城"));
//			 */
//			/*
//			 * System.out.println(UserInfoEncrypt.decode(
//			 * "/PlhTf71FN$tVBzoMus6BSyNWusJFlkp"));
//			 * System.out.println(UserInfoEncrypt
//			 * .decode("JBRWSNl1sANGO7M795ASyry$KWhecXVb"));
//			 */
//		}
//	}
//
//	/**
//	 * 获取in 条件,List里面的Object必须是继承IdEntity
//	 *
//	 * @param idEntities
//	 * @return
//	 */
//	public static String getInConditionStr(List<String> columnStrs, String name) {
//		StringBuffer inCondition = new StringBuffer("(" + name + " in (");
//		int flag = 0;
//		for (String str : columnStrs) {
//			if (RuiUtils.isTrimEmpty(str)) {
//				continue;
//			}
//			if (flag == 999) {
//				inCondition = new StringBuffer(inCondition.substring(0,
//						inCondition.length() - 1));
//				inCondition.append(") or " + name + " in (");
//				flag = 0;
//			}
//			inCondition.append("'" + str + "',");
//			flag++;
//		}
//		String str = inCondition.toString();
//		if (str.endsWith(",")) {
//			str = str.substring(0, str.length() - 1);
//		}
//		str += ") )";
//		return str;
//	}
//
//	public static String getFormattedAmount(String amount) {
//		if (null == amount || "".equals(amount) || "null".equals(amount)) {
//			amount = "0";
//		}
//		String format_string = "000000000000";
//
//		DecimalFormat pattern = new DecimalFormat(format_string);
//
//		amount = pattern.format(Double.parseDouble(amount) * 100);
//		return amount;
//	}
//
//	/**
//	 * 以指定字符串填补空位，右对齐字符串 rpadString("9",3,"0")==>"900"
//	 *
//	 * @param src
//	 * @param byteLength
//	 * @param single
//	 * @return
//	 */
//	public static String rpadString(String src, int length, String single) {
//		try {
//			if (src == null || length <= src.getBytes("GBK").length) {
//				return src;
//			} else {
//				return src
//						+ repeatString(single, length
//								- src.getBytes("GBK").length);
//			}
//		} catch (UnsupportedEncodingException e) {
//			return "";
//		}
//	}
//
//	/**
//	 * 以制定字符串填充空白位，左对其 rpadString("9",3,"0")==>"009"
//	 * @param src
//	 * @param length
//	 * @param single
//	 * @return
//	 */
//	public static String lpadString(String src, int length, String single) {
//		try {
//			if (src == null || length <= src.getBytes("GBK").length) {
//				return src;
//			} else {
//				return repeatString(single, length - src.getBytes("GBK").length) + src;
//			}
//		} catch (UnsupportedEncodingException e) {
//			return "";
//		}
//	}
//
//	/**
//	 * 重复字符串 如 repeatString("a",3) ==> "aaa"
//	 *
//	 * @author uke
//	 * @param src
//	 * @param repeats
//	 * @return
//	 */
//	public static String repeatString(String src, int repeats) {
//		if (null == src || repeats <= 0) {
//			return src;
//		} else {
//			StringBuffer bf = new StringBuffer();
//			for (int i = 0; i < repeats; i++) {
//				bf.append(src);
//			}
//			return bf.toString();
//		}
//	}
//
//	/**
//	 * yyyy-mm-dd格式化
//	 * @param date
//	 * @return
//	 */
//	public static String formatDate(Date date, String format){
//		SimpleDateFormat sdf=new SimpleDateFormat(format);
//		return 	sdf.format(date);
//	}
//
//	public static Date addDate(Date date, int days) {
//		Calendar _calendar = Calendar.getInstance();
//		_calendar.setTime(date);
//		_calendar.add(Calendar.DATE, days);
//		return _calendar.getTime();
//	}
//
//	public static String defaultFormate(Date date,String format){
//		return 	new SimpleDateFormat(format).format(date);
//	}
//
//	public static String defaultFormate(Date date){
//		return 	new SimpleDateFormat(defaultFormat).format(date);
//	}
//}
